﻿using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace CGF
{
    public static class StringHelper
    {
        /// <summary>
        /// 转成千位加逗号，自定义保留几位小数点
        /// </summary>
        /// <param name="value"></param>
        /// <param name="decimalPlaces">保留几位小数点</param>
        /// <returns></returns>
        public static string ToThousandFormat(long value, int decimalPlaces = 2)
        {
            return string.Format("{0:N" + decimalPlaces + "}", value);
        }

        /// <summary>
        /// 段落文本空格不自动换行,同时将文本里的\n符号转成换行符
        /// </summary>
        public static string SurportSpace(string text)
        {
            /*
            \u0020 换行空格
            \u00A0 不换行空格
            \u3000 中文排版对其空格（拉大空格使末尾对齐）
            */
            string tag = I18N.CurrLanguage == ELanguage.ZH_CN ? "\u00A0" : "\u0020";
            return text.Replace(" ", tag).Replace("\\n", "\n");
        }

        /// <summary>
        /// 判断是否是带BOM的UTF8格式
        /// </summary>
        public static bool HaveBOM(byte[] data)
        {
            int charByteCounter = 1;
            byte curByte;
            for (int i = 0; i < data.Length; i++)
            {
                curByte = data[i];
                if (charByteCounter == 1)
                {
                    if (curByte >= 0x80)
                    {
                        while (((curByte <<= 1) & 0x80) != 0)
                        {
                            charByteCounter++;
                        }
                        if (charByteCounter == 1 || charByteCounter > 6)
                        {
                            return false;
                        }
                    }
                }
                else
                {
                    if ((curByte & 0xC0) != 0x80)
                    {
                        return false;
                    }
                    charByteCounter--;
                }
            }
            return true;
        }

        /// <summary>
        /// 去掉头部的BOM
        /// </summary>
        public static string RemoveBOM(string content)
        {
            if (content == null) return null;

            byte[] buffer = Encoding.UTF8.GetBytes(content);
            if (buffer.Length <= 3)
            {
                return Encoding.UTF8.GetString(buffer);
            }
            byte[] bomBuffer = new byte[] { 0xef, 0xbb, 0xbf };
            if (buffer[0] == bomBuffer[0] && buffer[1] == bomBuffer[1] && buffer[2] == bomBuffer[2])
            {
                return new UTF8Encoding(false).GetString(buffer, 3, buffer.Length - 3);
            }
            return Encoding.UTF8.GetString(buffer);
        }

        /// <summary>
        /// 是否符合手机号码的格式
        /// </summary>
        public static bool IsPhoneNum(string phoneNum)
        {
            if (string.IsNullOrEmpty(phoneNum)) return false;
            phoneNum = phoneNum.Trim();

            Regex regex;
            switch (CGFConfig.Instance.ReleaseArea)
            {
                case EArea.China:
                default:
                    phoneNum = phoneNum.Replace("+86", "");
                    regex = new Regex(@"^1[345789]\\d{9}$");
                    break;
                case EArea.Brazil:
                    // 巴西手机号规则：
                    // 1. 通常以9、7、8开头（移动号码）
                    // 2. 总长度11位（包括2位区号）
                    // 3. 格式：(XX) 9XXXX-XXXX 或 XX 9XXXX XXXX
                    // 这里简化验证：去除非数字字符后检查
                    phoneNum = phoneNum.Replace("+55", "");
                    if (phoneNum.Length == 10 || phoneNum.Length == 11)
                    {
                        // 11位：完整号码（含区号），如11987654321
                        // 10位：可能省略了开头的0，如1187654321
                        return phoneNum.Length == 11
                            ? new Regex(@"^[1-9][1-9]9[0-9]{8}$").IsMatch(phoneNum) // 完整11位
                            : new Regex(@"^[1-9]9[0-9]{8}$").IsMatch(phoneNum); // 10位（省略区号前的0）
                    }
                    return false;
                case EArea.India:
                    phoneNum = phoneNum.Replace("+91", "");
                    if (phoneNum.StartsWith("2") && phoneNum.Length == 10)
                    {
                        //虚拟号码20开头
                        return true;
                    }
                    regex = new Regex(@"^[7-9][0-9]{9}$");
                    break;
                case EArea.Vietnam:
                    // 1. 国内格式：以0开头的10位数字（例如：0836132817）
                    // 2. 国际格式：+84开头后跟9位数字（例如：+84836132817）
                    // 3. 主要运营商号段：32-39, 52-59, 70-79, 81-89, 90-99
                    // 4. 运营商号段对应的是第2-3位数字（国内格式）或第1-2位数字（国际格式）
                    phoneNum = phoneNum.Replace("+84", "");
                    if (phoneNum.Length == 10 && phoneNum.StartsWith("0"))
                    {
                        phoneNum = phoneNum.Substring(1);
                    }
                    if (phoneNum.Length == 9)
                    {
                        Debug.Log($"phoneNum {phoneNum}");
                        // 验证前2位是否符合运营商号段，后7位为任意数字
                        regex = new Regex(@"^(3[2-9]|5[2-9]|7[0-9]|8[1-9]|9[0-9])[0-9]{7}$");
                        return regex.IsMatch(phoneNum);
                    }
                    return false;
            }
            return regex.IsMatch(phoneNum);
        }

        /// <summary>
        /// 限制位数的英文和字母（多用于密码）
        /// </summary>
        public static bool IsNumberAndLetter(string content, int min = 8)
        {
            if (string.IsNullOrEmpty(content)) return false;

            if (content.Length < min)
            {
                return false;
            }
            Regex regex = new Regex(@"(?=.*[A-Za-z])(?=.*[0-9])");
            return regex.IsMatch(content);
        }

        /// <summary>
        /// 是否包含特殊字符
        /// </summary>
        public static bool IsContainsSpecialChar(string input)
        {
            if (string.IsNullOrEmpty(input)) return false;
            string pattern = @"[!@#$%^&*()_+\-=\[\]{};':\\|,.<>\/?]";
            return Regex.IsMatch(input, pattern);
        }

        /// <summary>
        /// 是否是巴西PIX
        /// </summary>
        public static bool IsPIX(string input)
        {
            if (string.IsNullOrEmpty(input)) return false;
            string pattern = @"^\d{3}\.\d{3}\.\d{3}-\d{2}$";
            return Regex.IsMatch(input, pattern);
        }

        /// <summary>
        /// 是否符合IPV4的格式
        /// </summary>
        public static bool IsIPV4(string ip)
        {
            if (string.IsNullOrEmpty(ip)) return false;
            return Regex.IsMatch(ip, @"^((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)$");
        }

        /// <summary>
        /// 是否符合Email的格式
        /// </summary>
        public static bool IsEmail(string content)
        {
            if (string.IsNullOrEmpty(content)) return false;
            return Regex.IsMatch(content, @"^[^@\s]+@[^@\s]+\.[^@\s]+$");
        }

        /// <summary>
        /// 是否符合印度IFSC码的格式
        /// </summary>
        public static bool IsIndiaIFSC(string content)
        {
            if (string.IsNullOrEmpty(content)) return false;
            return Regex.IsMatch(content, @"^[A-Za-z]{4}[0][A-Za-z0-9]{6}$");
        }

        /// <summary>
        /// 是否包含中文
        /// </summary>
        public static bool IsContainChinese(string content)
        {
            if (string.IsNullOrEmpty(content)) return false;
            return Regex.IsMatch(content, @"[\u4e00-\u9fa5]");
        }

        /// <summary>
        /// 是否是数字
        /// </summary>
        public static bool IsInt(string str)
        {
            return int.TryParse(str, out int result);
        }

        /// <summary>
        /// 是否包含数字
        /// </summary>
        public static bool IsContainNumber(string content)
        {
            if (string.IsNullOrEmpty(content)) return false;
            return Regex.IsMatch(content, @"\d");
        }

        /// <summary>
        /// 是否是字母开头
        /// </summary>
        public static bool IsStartWithLetter(string content)
        {
            if (content.Length > 0 && char.IsLetter(content[0]))
            {
                return true;
            }
            return false;
        }

        /// <summary>
        /// 中文转Unicode
        /// </summary>
        public static string UnicodeEncode(string cnStr)
        {
            byte[] unicodeBytes = Encoding.Unicode.GetBytes(cnStr);
            StringBuilder stringBuilder = new StringBuilder();
            for (int i = 0; i < unicodeBytes.Length; i += 2)
            {
                stringBuilder.Append("\\u");
                stringBuilder.Append(unicodeBytes[i + 1].ToString("X2"));
                stringBuilder.Append(unicodeBytes[i].ToString("X2"));
            }
            return stringBuilder.ToString();
        }

        /// <summary>
        /// Unicode转中文
        /// </summary>
        public static string UnicodeDecode(string unicode)
        {
            return Regex.Unescape(unicode);
        }
    }
}
